{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = np.sin(x_mesh+y_mesh*5)+np.exp(-x_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x172f4e40640>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAcQklEQVR4nO3dbaxdVZ3H8e+/ty1WqAVBkClVUetTJpBRBGOcETWMhXlBTExEjGaIpmFGjJnMJJiZjL7wDb6YjBjRpiGEOC/sCzVaJygxMYqJdqxOBKFGppYIF4wMD4M8KH36z4tzD3ff3XPv2fecvff6r7V/n4TQ03N6z+ruvb/fWuvss4+5OyIiUr4NqQcgIiL9UOCLiAyEAl9EZCAU+CIiA6HAFxEZCAW+iMhATA18M7vNzB41s3tXud/M7AtmdtjM7jGzN7c/TBERmVeTGf7twK417r8S2Ln0327gy/MPS0RE2jY18N39LuCJNR5yNfAVHzkAnGlm57c1QBERacfGFr7GduChyu3Fpd/7Xf2BZrab0SqADRs3v+VFLzm3hadfacMJvXNYZMhOLljqIXTquScWH3P3l83yZ9sI/ElHd2LquvteYC/A6Wfv8D//m39o4elHTnvqRGtfS0TK9vy2hdRDmNlP/+Mffzvrn20j8BeBHZXbFwCPtPB1p1LIi8gsZsmOnEtirI3A3w/cYGb7gMuAp9z9lO2cNinoRaRvs+ZOpKKYGvhm9lXgcuAcM1sEPgNsAnD3PcAdwFXAYeA54LquBgsKe1ndpqeOtf41j23b1PrXlGGJtJqYGvju/sEp9zvw8dZGtAoFfWxdhG0Eufy9VExl6Srv2tjS6ZSCvl+5BJys1Me/m0olf2EDX0HfPoW5zENbZvkLGfgK+/VTmEuO2vq+VXE0EyrwFfTTKdhFTqXiaCZE4CvoT6VgF+nfvD930QsjaeAr6EcU7iJlmOdnuY+ySBr4z29bGHToK+hFZKyPPNAHoCSisBeRviUP/EhvO+6Lwl5EUkge+DCs0FfYi0gqIc7SGQqFfTk2PfnH1EPIyrGztqQeghAo8Et/AVdhH49Cuz99HWsVy9rCBL5IGxTiw9bFv39JJRIq8Eud5Wt23z4Fu/Slre+1CMURKvBLpLCfnUJdStLG9/O8pREu8Eua5Svsm1O4i0w3789JuMCH5dM0Swl+WUnhLpJGiPPwV/P8toWsz9GPfiGlFBT2IumEDvwxhb6IyPyyCHzIe7av0BeRCLIJ/LFcg//Ytk2DD35t54iklV3gj+Uc/CIiKWQb+GM5Br9CX0RSCHla5ixyO3//2LZNgzpPX9s5w2VPPp16CK3ys7amHsLMigl8yO/8/aGFvuSltKBuS6rj0kbRFBX4YzkF/3h7p+Tg1+w+FgV5ntr4dysy8Mdy2ubRbF/aokCX1RQd+LDyTVvRw7/U2f6xs7Zolt8BBbusV/GBX5VL+JcY/OOr/Cn426Gwl1kMKvCrcgj/6umbpYS/gl8knWTn4fsCHN1qqZ5+hRzO5S/tnbrHztoS4gMhRIYk+Qy/Gvqbn/aEI9GsPwXN+NdP2zkyq1DvtD261TTrX4eSZv2a8Yt0L/kMfxLN+tenpFm/zuhZm2b3Mo+QgV8VMfyjBj+UcYaPtnlEutFoS8fMdpnZr83ssJl9asL928zs22Z2t5ndZ2bXtT/UOFs+4+2eyFs+JWz3aItnJc3uZV5TA9/MFoBbgCuBNwEfNLM31R72ceCQu18MXA78m5ltbnmsLxgHf6Twjyr34Nfevkh7mmzpXAocdvcjAGa2D7gaOFR5jANbzcyAM4AngOMtj3WiKFs+0ff6c9/q0TaPyPyaBP524KHK7UXgstpjvgjsBx4BtgIfcPeT9S9kZruB3QCbzjhrlvGuSeE/XX22n1sBVGf7Qwv/8dUStbUjs2oS+JP2Tepp+l7gF8C7gdcA3zOzH7n7H1b8Ife9wF6AF5+7o9NEjhj+ELsAFP55UPDLrJoE/iKwo3L7AkYz+arrgJvc3YHDZvYA8Abgp62Mck71vf4oBaDwb88Qw1/BL+vVJPAPAjvN7ELgYeAa4NraYx4E3gP8yMzOA14PHFnri44urTD69eaev18jzv4V/u0ZWvhXPxhD4V+mk48/0crXmRr47n7czG4A7gQWgNvc/T4zu37p/j3AZ4HbzeyXjLaAbnT3x5oO4mjlg1wU/iORCqCE8B9C8INm/SVoK9wnafTGK3e/A7ij9nt7Kr9+BPjrNgZ0tPYpXn0WgLZ+psv1Rd+hzvoV/LF1Ge6TZPBO2+Vfa/YfK/whz9n/kMJfwR9L3wFfFz7wqxT+Cv+2DSX8FfxppQ76sawCvyrK1o/Cf7Kcw1/BL22JEvRj2QZ+XarZv8J/utze5TuEWb+Cv1vRgn6smMCvihD+o+dOUwBRz/jJ8QXf0sNfwd+uqEE/lizwvaePXomy9TN6bhVAVW4FUL+IW0kFoHP527Hh7JcCcYM/6Qz/2Bkrb296pvvnjFIA2v45VW77/qUWQDX8QQUwi6jBH2pLJ3UBaPYfpwBym/1Duds/mv3PLlrwhwr8umoBDGn2P3puFUBVbgWg2b9UjYMf0oZ/6MCvSj37BxUAqABmNYQCUPg3k3LWn03g16kAVABVOReAwn+YNpz9Ul1aYVZ9b/+A3vkLegG4DSXO/rX100zfs/1iAr9Ks3/N/qs0+09Ps/+19RX86c7DX4DjL1n+FMSNf+juxHwVgAqgSrP/tPRmr9V1vc0TZobfV/iDtn9Sibj9o9l/Opr1T9blbD9M4FdVwx80+2/3uTX7X0tOBVDS7F97/qfq4lTOkIFfpwLo8rlVAGtRAaShAlipGv48N/vXySLw61QAXT63nfJ7KUqgXgAQowTqBQBxS0AFIHVZBn5dqv1/KL8ARs+vVcBaclkF1AsA8i2BegGASqCJIgK/qs/ZP8QoANA2EKgAZqFVwLCkC/wNzokzln9AF545dQnfhiEUAMTaBopSABCjBHIuAMi3BFQApwozw6+GP6gA5qUCGIm4CsjpdQAoZxWgAggU+HUqgHZFKoDR88dYBUQoAMh7FaACyEfYwK/rY/sHVAB9ibIKUAHMTwWQj2wCv6qv2T+oAPqiAlibCqB/Jb4TOMvAr1MBtE8FMKICmF8JBVDK7D9Z4NtCdz/AKoD2qQBGcjkTCOKWgAognaQz/E1nHF1x+9gzmzt5niEVAAzzvQCj51cJVOWyCijhVNBc3ggWaktHBdAOrQKqY4hRAhELAFQCXYpYAqECv24IBQDD2QaC9CUQpQBAJbBeKoH5hQ78uhILAIazDQRaBVSpBOanElifrAK/TgXQHq0Cqs+vdwbX5VwCuRUAdFcCWQd+nQqgPakKALQKqIq6CgC9KNy3F0rgodm/RrLAX9hwkm1bRwf9qadP/QdpQ6oCgPJfCAatAlKJWgI5rwIgzxJYr0aBb2a7gJuBBeBWd79pwmMuBz4PbAIec/d3Nh3EOPjHci8AKP+FYNAqoC5SCUQoAMi7BEosgKmBb2YLwC3AFcAicNDM9rv7ocpjzgS+BOxy9wfN7Nx5BqUCmF+EVUDKAoD0JRCpACBuCeRSAJB/CTSZ4V8KHHb3IwBmtg+4GjhUecy1wDfc/UEAd3+0zUGqAOYXoQBAq4BIJRC1ACCfEsitAJoE/nZWvkywCFxWe8zrgE1m9gNgK3Czu3+l/oXMbDewG2DzuS+ZZbyACqAN2gYaGXIJaBUwv9xWAU0C/9TvUKh/h24E3gK8B9gC/MTMDrj7/Sv+kPteYC/A6TvPb+27fAgFAFoFdCH1KmA0BpXANJNWARCzCCKXQJPAXwR2VG5fADwy4TGPufuzwLNmdhdwMXA/CVQLoKvwh34LAIa7CoBhnRE0GodKoIlctoMmlQD0XwRNAv8gsNPMLgQeBq5htGdf9S3gi2a2EdjMaMvn39d84oWTnHv68k/xo89O+ClvQV+zfyi/ACDNKgC0FTQah0qgiVxKAPpfDUwNfHc/bmY3AHcyOi3zNne/z8yuX7p/j7v/ysy+C9wDnGR06ua96xlINfxBBTCLCAUA5a8CQCUwiUqgHV2WgLmn+ebY9obz/O17r2n8+K4KoK7LApik6xKo66ME6vpaBUzSZwlMkqIETh1DujODJolSApNELYGq7//wX37u7pfM8mezubRCqhUAaBUwr1SrAEi7FQR6UXiS3FYCkEcRNJFN4Nf1VQAwrG0gGNZrAaCtoOVxxCoBiF0EOZZAtoFfpwJoz9BXAaASWB5H2u2gqG8WgzxLIFngb97Q7T/cUAoAtAroQrStIFAJQOztIIhfAkln+Dte/H8rbj/03JmdPVepBQBaBfQh9SoAVAKrya0EUhZAqC0dFUA7IhQAqAT6oBKYLPJrAilfGA4V+HUqgHak2AaCNKsAiLUVBCqBleOI9ZoAxCgB6KcIQgd+XbUAugx/oJd3AY/1XQCgVYBKIE4JQLzVQJQSgNWLYBZZBX5VqbN/GE4BQJxVAKgEIN0bxaKtBiJvCc0j28CvG1IBwHC2gUAl0CeVwNqirwamKSbw61Jt/0A/l4HQKqAfKV8PAJVAXS4lADGLIN15+HacV255/IXbv/3j2Z09V5+zfxhuAYBWAX1QCawU8XUBiLkaCDPD7yv8IX0BQJnbQBBnFQAqgQglALGKYOglECbwq6rhD+UVAGgV0AeVwKm/l+LqodFXAxFLALopgpCBX6cC6EaKAoB0qwCI9XoAqASqVAIrdbEayCLw61QA3YiyDQTDWAWASqAqeglA+iJYbTXQVJaBX9fn/j8MpwAgzioAVAJ9UglMFnU10FQRgV/V9+wfVAB9GepWEKgEqnJ4cRhiFkFxgV/X9+wf+n0PwJgKIG0BgEpgLNXHSmo1MF2ywH/RhmO89rTfA3D4+fN6ec7U4Q/DKwAYxjYQqATGJpUAxFkNRCsB6K8IQszwx8E/1kcBpNj6geEVAMRaBYBKANJ8sHyU1UC0LSHorwhCBH5dtQBSzP5BBdCllKsASLsVBCqBqiglAPFWA7B6EcwqZOBXpQh/SLP9A3EKALQK6JNKYFn0EoD0RTCr8IFfFSH8YRgFAFoF1KkERqKUAMQqghxKIKvAr0qx7z+mAhjpswAg7SoAVAJjUUoAtBpYr2wDv04FMJKyAGBYqwBQCYxNKgGIsxpIVQIQazVQTODXpdr+geEWAMRbBYBKYKzvEoA4q4EctoSg+yIoNvCrUoY/pHsBGFQAkH4rCNKfGQQqgUmGthpI+gEoKQw5/EEFADELAFQCdZFKAOKtBmaRdIb/6s3/+8Kvjxx9We/PP/TwhzSXgaiKWAAQowRSFACoBFYTbTUwizBbOgr/dPv+Y6ln/5D+heAxrQJWilwCoNVAU2ECv2oc/imCH9KHP6gAqrQKWKYSmEyrgWZCBv5Y6lk/pD3dsyra9g8MuwAgxioAVAKryaEEoN8iCB34VRHCHzT7r1IBrBRlFQAqgdVE2xKCflcD2QR+lcJ/JRXASlFeBwCVwGomlQDEKoJoJQDzF0GjwDezXcDNwAJwq7vftMrj3gocAD7g7l+bb2jNRAx/UAHAqQUAKgFQCaxFq4G1rVYETU0NfDNbAG4BrgAWgYNmtt/dD0143OeAO+cb0uyihD/Emf1DnAKAOKsAiLMVBCqBtUQqAYi3GliPJjP8S4HD7n4EwMz2AVcDh2qP+wTwdeCtrY5wRlHDH2IVQMrwh9gFACqBsRxKALQamKZJ4G8HHqrcXgQuqz7AzLYD7wPezRqBb2a7gd0AL9/e3z9M6tM86/r+aMe1RAp/iFUAEGsVAHHODIJ4JQBaDUzTJPAnfeRK/XO3Pg/c6O4nzFb/hBZ33wvsBXjjRaf1/mm+UYMf4oU/qAAmiV4AoBKoy6EEoJ8iaBL4i8COyu0LgEdqj7kE2LcU9ucAV5nZcXf/ZhuDbFu04Id44Q/xZv+Q/lIQddEKAGKtAkAl0FQfq4EmgX8Q2GlmFwIPA9cA11Yf4O4Xjn9tZrcD/xk17Ksi7fNXRQ9/iFEA0Wb/kEcBgEpgklxKYB5TA9/dj5vZDYzOvlkAbnP3+8zs+qX797Q6okQizvohZvhD/Nk/xCwAUAmsJpcSgPRFMCtz730rHYC/uHiz7/32nyV57qaihX9VpPCvihL+k0QogEkiFMAkqQtgNalLYDV9lcADn/ynn7v7JbP82aTvtN25cdSe/3M8ZltGnfVDHjN/iFUAEVcAoFXAekVcCUDMLaG6EJdWyCX4QeG/XiqA2agE1mdSCUD6Ioi2JRQi8MeiBz/EnvVD7PCHvAoAYpdAhAKAuCUAea0GoPsiCBX4YzkFP+QR/qACmIVWAbNRCcym622hkIE/tnPjidChPxZ91j8WffYPMc/+qYpcAKASmFXULSFYfTUwi9CBD/mEPuQT/BDr8g6riR7+EL8AIO5WEMQuAYi9GphF+MCHvEIfFPxdyCH8Id47gSeJXACgEuhSFoEP+YU+jII/h9CHfIIf8gx/UAHMI9rlIupyKYFsAj9XOc32IY99/qroL/pWqQDaE30VADFLIKvAz3GWP5bTbH8st/CHfGb/kG8BgEpgVqlLIKvAh/xDH/KZ7VfltOUzllP4Qz4FACqBNvV5hlB2gV+CEoIf8g1/UAF0IYetIMijBKCb1UCWgZ/zLL8qx22eqlzDH/Kb/UP8dwLX5bIKgLxLYD2yDHwoK/Qhz9l+VY5bPmM5zv7Hcl8FQF4lADGLoKlsA780pQU/5Bn+oALoW04lAPmsBibJOvBLmeVX5b7NU1VC+EOe2z9jORYAqAS6knXglxb2YyWF/thrT/t91qE/lnP4Q74FAPm8KDwWsQSyDPxSg750Oe/zTzIO/xyDfyyHS0GsJrcCgPQlkF3gK+zzV2rwQznhDyqAvvR52YhsAl9BX55StnmqSgl/yHv2D+UUALRXAlkEvsK+XKXN9qtKDX8oowAg7xKYRejAV9APR4mz/aqSwh/KKADIuwRmETLwFfRlnqkzTcmz/arSwh/KKQDIdyuoiXCBr7CXoQQ/lBn+UHYBQL4lECbwFfRSN6Tgh3LDH/K7DtA0uZZAiMBX2Mtahhb8kPflHZoqaRUAk0sAYhVB0sBX0Mt6lP7C7lpKnv2PlVYAY5FeE0gW+H9yS/XU4Q3txVpZn1duebzY0K/K/X0Aq0lZACG2dGREQS9NlXBZh/UoNfyh3wJQ4CemkG9uqNs5axla8EO5Wz9jXb4grMDvmQJeujDE4B8refY/ttoLwuulwO+BQl76MuTgh/Jn//NS4HdAAd8+beesz9CDf2wIs//1UOC3RCEvESn4l2n23zDwzWwXcDOwANzq7jfV7v8QcOPSzWeAv3P3u9scaDQKeMnJEM7jX68hFsDUwDezBeAW4ApgEThoZvvd/VDlYQ8A73T3J83sSmAvcFkXA05B4Z6WtnPapVn/ZKVd/mGSJjP8S4HD7n4EwMz2AVcDLwS+u/+48vgDwAVtDrJPCncZCs36pyttFdAk8LcDD1VuL7L27P2jwHcm3WFmu4HdAC/fnv6yCgr3+DS778dQ3r07r9xfBG4S+JOugeATH2j2LkaB/45J97v7XkbbPbzxotMmfo22KMzzpZDvn8J+/XIM/yaBvwjsqNy+AHik/iAzuwi4FbjS3R+v398GhXh5FO5SgnH4Rw/+JoF/ENhpZhcCDwPXANdWH2BmrwC+AXzY3e9fzwAU4sOgYJchiD7rnxr47n7czG4A7mR0WuZt7n6fmV2/dP8e4NPA2cCXzAzguLtfstbXPeobFfaFUrjnRds53Yg46290Hr673wHcUfu9PZVffwz4WLtDk8gU6iLNRJr16522MpECXaR9qcNfgT9QCnQBbeeklOIcfwV+YRTkInnqY/avwA9OAS4yPF3N/hX4PVJ4i8gsJl3nZxYK/HVQYEtJtH8/PMUFvkJZ5FQKd4GEgf+nk5sUziItUaBLE8XN8EVKpECXNijwRRJSkEufFPgiLVF4S3QKfBk8BbUMhQJfwlMgi7RDgS8rKFxFyqXAn4PCUURykizwj/pGBaaISI82pB6AiIj0Q4EvIjIQCnwRkYFQ4IuIDITO0hERCazNT79S4IuIJNL3B5lnGfgpPu09F219Mo6INJNTHqU7D//kQlYHKhc6pnlSUbdD3/9ry3KGL1IaBZX0QWfpiIgMhAJfRGQgFPgiIgOhwBcRGYiwL9o++uwZjR977unPdDgSEZEyJAv84yc2rCvU19LW1xGVp0jJws7wJY1cylPFJLJ+CnzJUpRiUvFIThT4InNIVTwqGpmFAl8kQ30WjcqlHI0C38x2ATcDC8Ct7n5T7X5buv8q4Dngb939v1seq4gk0HW5qFD6MzXwzWwBuAW4AlgEDprZfnc/VHnYlcDOpf8uA7689P9VnTi5gaee3jLruEPZtvWPqYcgkq0uC0VlslKTGf6lwGF3PwJgZvuAq4Fq4F8NfMXdHThgZmea2fnu/rvWRxxQbsWlgpKhaLtMci+QJoG/HXiocnuRU2fvkx6zHVgR+Ga2G9i9dPP533zgX+9d12jLdQ7wWOpBBKFjsUzHYpmOxbLXz/oHmwS+Tfg9n+ExuPteYC+Amf3M3S9p8PzF07FYpmOxTMdimY7FMjP72ax/tsm1dBaBHZXbFwCPzPAYERFJqEngHwR2mtmFZrYZuAbYX3vMfuAjNvI24Kmh7N+LiORi6paOux83sxuAOxmdlnmbu99nZtcv3b8HuIPRKZmHGZ2WeV2D594786jLo2OxTMdimY7FMh2LZTMfCxudWCMiIqXT9fBFRAZCgS8iMhCdB76Z7TKzX5vZYTP71IT7zcy+sHT/PWb25q7HlEqDY/GhpWNwj5n92MwuTjHOPkw7FpXHvdXMTpjZ+/scX5+aHAszu9zMfmFm95nZD/seY18a/IxsM7Nvm9ndS8eiyeuF2TGz28zsUTOb+F6lmXPT3Tv7j9GLvL8BXg1sBu4G3lR7zFXAdxidy/824L+6HFOq/xoei7cDZy39+sohH4vK477P6KSA96ced8LvizMZvbP9FUu3z0097oTH4p+Bzy39+mXAE8Dm1GPv4Fj8FfBm4N5V7p8pN7ue4b9wWQZ3PwqML8tQ9cJlGdz9AHCmmZ3f8bhSmHos3P3H7v7k0s0DjN7PUKIm3xcAnwC+Djza5+B61uRYXAt8w90fBHD3Uo9Hk2PhwNalCzaewSjwj/c7zO65+12M/m6rmSk3uw781S65sN7HlGC9f8+PMmrwEk09Fma2HXgfsKfHcaXQ5PvidcBZZvYDM/u5mX2kt9H1q8mx+CLwRkZv7Pwl8El3P9nP8EKZKTe7vh5+a5dlKEDjv6eZvYtR4L+j0xGl0+RYfB640d1PjCZzxWpyLDYCbwHeA2wBfmJmB9z9/q4H17Mmx+K9wC+AdwOvAb5nZj9y9z90PLZoZsrNrgNfl2VY1ujvaWYXAbcCV7r74z2NrW9NjsUlwL6lsD8HuMrMjrv7N3sZYX+a/ow85u7PAs+a2V3AxUBpgd/kWFwH3OSjjezDZvYA8Abgp/0MMYyZcrPrLR1dlmHZ1GNhZq8AvgF8uMDZW9XUY+HuF7r7q9z9VcDXgL8vMOyh2c/It4C/NLONZvZiRler/VXP4+xDk2PxIKOVDmZ2HqMrRx7pdZQxzJSbnc7wvbvLMmSn4bH4NHA28KWlme1xL/AKgQ2PxSA0ORbu/isz+y5wD3CS0afOFXdp8YbfF58FbjezXzLa1rjR3Yu7bLKZfRW4HDjHzBaBzwCbYL7c1KUVREQGQu+0FREZCAW+iMhAKPBFRAZCgS8iMhAKfBGRgVDgi4gMhAJfRGQg/h8Ya0/X+JsIuQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contourf(x_domain, y_domain, truth_smooth,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = truth_smooth + np.random.normal(loc=0.0, scale=0.4, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.84264 | domain_loss:  558.45874 | bdc_loss:    1.27076\n",
      "epoch:  200.00000 | total_loss:    2.45456 | domain_loss:  123.41373 | bdc_loss:    1.23275\n",
      "epoch:  400.00000 | total_loss:    1.59494 | domain_loss:   40.81737 | bdc_loss:    1.19875\n",
      "epoch:  600.00000 | total_loss:    1.33186 | domain_loss:   17.64149 | bdc_loss:    1.16711\n",
      "epoch:  800.00000 | total_loss:    1.21800 | domain_loss:    9.26060 | bdc_loss:    1.13676\n",
      "epoch: 1000.00000 | total_loss:    1.15241 | domain_loss:    5.66499 | bdc_loss:    1.10683\n",
      "epoch: 1200.00000 | total_loss:    1.10495 | domain_loss:    3.89748 | bdc_loss:    1.07674\n",
      "epoch: 1400.00000 | total_loss:    1.06497 | domain_loss:    2.92496 | bdc_loss:    1.04618\n",
      "epoch: 1600.00000 | total_loss:    1.02823 | domain_loss:    2.32792 | bdc_loss:    1.01510\n",
      "epoch: 1800.00000 | total_loss:    0.99319 | domain_loss:    1.91984 | bdc_loss:    0.98383\n",
      "epoch: 2000.00000 | total_loss:    0.95975 | domain_loss:    1.61606 | bdc_loss:    0.95312\n",
      "epoch: 2200.00000 | total_loss:    0.92856 | domain_loss:    1.37889 | bdc_loss:    0.92401\n",
      "epoch: 2400.00000 | total_loss:    0.90061 | domain_loss:    1.19132 | bdc_loss:    0.89767\n",
      "epoch: 2600.00000 | total_loss:    0.87677 | domain_loss:    1.04354 | bdc_loss:    0.87509\n",
      "epoch: 2800.00000 | total_loss:    0.85748 | domain_loss:    0.92693 | bdc_loss:    0.85678\n",
      "epoch: 3000.00000 | total_loss:    0.84253 | domain_loss:    0.83340 | bdc_loss:    0.84262\n",
      "epoch: 3200.00000 | total_loss:    0.83118 | domain_loss:    0.75690 | bdc_loss:    0.83193\n",
      "epoch: 3400.00000 | total_loss:    0.82237 | domain_loss:    0.69407 | bdc_loss:    0.82366\n",
      "epoch: 3600.00000 | total_loss:    0.81498 | domain_loss:    0.64332 | bdc_loss:    0.81671\n",
      "epoch: 3800.00000 | total_loss:    0.80808 | domain_loss:    0.60349 | bdc_loss:    0.81015\n",
      "epoch: 4000.00000 | total_loss:    0.80099 | domain_loss:    0.57331 | bdc_loss:    0.80329\n",
      "epoch: 4200.00000 | total_loss:    0.79323 | domain_loss:    0.55136 | bdc_loss:    0.79567\n",
      "epoch: 4400.00000 | total_loss:    0.78440 | domain_loss:    0.53628 | bdc_loss:    0.78691\n",
      "epoch: 4600.00000 | total_loss:    0.77414 | domain_loss:    0.52692 | bdc_loss:    0.77664\n",
      "epoch: 4800.00000 | total_loss:    0.76200 | domain_loss:    0.52228 | bdc_loss:    0.76442\n",
      "epoch: 5000.00000 | total_loss:    0.74741 | domain_loss:    0.52143 | bdc_loss:    0.74969\n",
      "epoch: 5200.00000 | total_loss:    0.72968 | domain_loss:    0.52330 | bdc_loss:    0.73176\n",
      "epoch: 5400.00000 | total_loss:    0.70798 | domain_loss:    0.52646 | bdc_loss:    0.70982\n",
      "epoch: 5600.00000 | total_loss:    0.68148 | domain_loss:    0.52914 | bdc_loss:    0.68302\n",
      "epoch: 5800.00000 | total_loss:    0.64951 | domain_loss:    0.52969 | bdc_loss:    0.65072\n",
      "epoch: 6000.00000 | total_loss:    0.61184 | domain_loss:    0.52759 | bdc_loss:    0.61269\n",
      "epoch: 6200.00000 | total_loss:    0.56896 | domain_loss:    0.52440 | bdc_loss:    0.56941\n",
      "epoch: 6400.00000 | total_loss:    0.52217 | domain_loss:    0.52313 | bdc_loss:    0.52217\n",
      "epoch: 6600.00000 | total_loss:    0.47344 | domain_loss:    0.52576 | bdc_loss:    0.47291\n",
      "epoch: 6800.00000 | total_loss:    0.42503 | domain_loss:    0.53149 | bdc_loss:    0.42395\n",
      "epoch: 7000.00000 | total_loss:    0.37915 | domain_loss:    0.53912 | bdc_loss:    0.37754\n",
      "epoch: 7200.00000 | total_loss:    0.33769 | domain_loss:    0.54956 | bdc_loss:    0.33555\n",
      "epoch: 7400.00000 | total_loss:    0.30201 | domain_loss:    0.56428 | bdc_loss:    0.29936\n",
      "epoch: 7600.00000 | total_loss:    0.27283 | domain_loss:    0.58347 | bdc_loss:    0.26969\n",
      "epoch: 7800.00000 | total_loss:    0.25019 | domain_loss:    0.60682 | bdc_loss:    0.24659\n",
      "epoch: 8000.00000 | total_loss:    0.23348 | domain_loss:    0.63405 | bdc_loss:    0.22944\n",
      "epoch: 8200.00000 | total_loss:    0.22166 | domain_loss:    0.66441 | bdc_loss:    0.21719\n",
      "epoch: 8400.00000 | total_loss:    0.21351 | domain_loss:    0.69657 | bdc_loss:    0.20863\n",
      "epoch: 8600.00000 | total_loss:    0.20782 | domain_loss:    0.72902 | bdc_loss:    0.20256\n",
      "epoch: 8800.00000 | total_loss:    0.20358 | domain_loss:    0.76109 | bdc_loss:    0.19795\n",
      "epoch: 9000.00000 | total_loss:    0.20004 | domain_loss:    0.79456 | bdc_loss:    0.19403\n",
      "epoch: 9200.00000 | total_loss:    0.19677 | domain_loss:    0.83165 | bdc_loss:    0.19036\n",
      "epoch: 9400.00000 | total_loss:    0.19353 | domain_loss:    0.86777 | bdc_loss:    0.18672\n",
      "epoch: 9600.00000 | total_loss:    0.19005 | domain_loss:    0.89723 | bdc_loss:    0.18291\n",
      "epoch: 9800.00000 | total_loss:    0.18627 | domain_loss:    0.92228 | bdc_loss:    0.17884\n",
      "epoch: 10000.00000 | total_loss:    0.18232 | domain_loss:    0.94182 | bdc_loss:    0.17465\n",
      "epoch: 10200.00000 | total_loss:    0.17802 | domain_loss:    0.93776 | bdc_loss:    0.17035\n",
      "epoch: 10400.00000 | total_loss:    0.17283 | domain_loss:    0.89014 | bdc_loss:    0.16558\n",
      "epoch: 10600.00000 | total_loss:    0.16615 | domain_loss:    0.78794 | bdc_loss:    0.15987\n",
      "epoch: 10800.00000 | total_loss:    0.15799 | domain_loss:    0.63849 | bdc_loss:    0.15313\n",
      "epoch: 11000.00000 | total_loss:    0.14968 | domain_loss:    0.49221 | bdc_loss:    0.14622\n",
      "epoch: 11200.00000 | total_loss:    0.14311 | domain_loss:    0.39732 | bdc_loss:    0.14054\n",
      "epoch: 11400.00000 | total_loss:    0.13872 | domain_loss:    0.34047 | bdc_loss:    0.13668\n",
      "epoch: 11600.00000 | total_loss:    0.13595 | domain_loss:    0.30583 | bdc_loss:    0.13423\n",
      "epoch: 11800.00000 | total_loss:    0.13411 | domain_loss:    0.28410 | bdc_loss:    0.13259\n",
      "epoch: 12000.00000 | total_loss:    0.13275 | domain_loss:    0.27006 | bdc_loss:    0.13136\n",
      "epoch: 12200.00000 | total_loss:    0.13165 | domain_loss:    0.26097 | bdc_loss:    0.13035\n",
      "epoch: 12400.00000 | total_loss:    0.13073 | domain_loss:    0.25494 | bdc_loss:    0.12948\n",
      "epoch: 12600.00000 | total_loss:    0.12994 | domain_loss:    0.25102 | bdc_loss:    0.12872\n",
      "epoch: 12800.00000 | total_loss:    0.12925 | domain_loss:    0.24835 | bdc_loss:    0.12804\n",
      "epoch: 13000.00000 | total_loss:    0.12864 | domain_loss:    0.24679 | bdc_loss:    0.12745\n",
      "epoch: 13200.00000 | total_loss:    0.12809 | domain_loss:    0.24605 | bdc_loss:    0.12690\n",
      "epoch: 13400.00000 | total_loss:    0.12760 | domain_loss:    0.24599 | bdc_loss:    0.12641\n",
      "epoch: 13600.00000 | total_loss:    0.12716 | domain_loss:    0.24651 | bdc_loss:    0.12595\n",
      "epoch: 13800.00000 | total_loss:    0.12676 | domain_loss:    0.24798 | bdc_loss:    0.12554\n",
      "epoch: 14000.00000 | total_loss:    0.12639 | domain_loss:    0.24941 | bdc_loss:    0.12515\n",
      "epoch: 14200.00000 | total_loss:    0.12606 | domain_loss:    0.25144 | bdc_loss:    0.12480\n",
      "epoch: 14400.00000 | total_loss:    0.12576 | domain_loss:    0.25412 | bdc_loss:    0.12447\n",
      "epoch: 14600.00000 | total_loss:    0.12550 | domain_loss:    0.25748 | bdc_loss:    0.12417\n",
      "epoch: 14800.00000 | total_loss:    0.12526 | domain_loss:    0.26102 | bdc_loss:    0.12389\n",
      "epoch: 15000.00000 | total_loss:    0.12505 | domain_loss:    0.26534 | bdc_loss:    0.12364\n",
      "epoch: 15200.00000 | total_loss:    0.12487 | domain_loss:    0.27063 | bdc_loss:    0.12340\n",
      "epoch: 15400.00000 | total_loss:    0.12472 | domain_loss:    0.27692 | bdc_loss:    0.12318\n",
      "epoch: 15600.00000 | total_loss:    0.12458 | domain_loss:    0.28425 | bdc_loss:    0.12297\n",
      "epoch: 15800.00000 | total_loss:    0.12446 | domain_loss:    0.29299 | bdc_loss:    0.12275\n",
      "epoch: 16000.00000 | total_loss:    0.12435 | domain_loss:    0.30340 | bdc_loss:    0.12254\n",
      "epoch: 16200.00000 | total_loss:    0.12425 | domain_loss:    0.31587 | bdc_loss:    0.12231\n",
      "epoch: 16400.00000 | total_loss:    0.12415 | domain_loss:    0.33079 | bdc_loss:    0.12207\n",
      "epoch: 16600.00000 | total_loss:    0.12406 | domain_loss:    0.34855 | bdc_loss:    0.12179\n",
      "epoch: 16800.00000 | total_loss:    0.12395 | domain_loss:    0.36966 | bdc_loss:    0.12147\n",
      "epoch: 17000.00000 | total_loss:    0.12383 | domain_loss:    0.39455 | bdc_loss:    0.12110\n",
      "epoch: 17200.00000 | total_loss:    0.12370 | domain_loss:    0.42355 | bdc_loss:    0.12067\n",
      "epoch: 17400.00000 | total_loss:    0.12353 | domain_loss:    0.45701 | bdc_loss:    0.12017\n",
      "epoch: 17600.00000 | total_loss:    0.12333 | domain_loss:    0.49526 | bdc_loss:    0.11958\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.12309 | domain_loss:    0.53865 | bdc_loss:    0.11889\n",
      "epoch: 18000.00000 | total_loss:    0.12278 | domain_loss:    0.58751 | bdc_loss:    0.11808\n",
      "epoch: 18200.00000 | total_loss:    0.12238 | domain_loss:    0.64225 | bdc_loss:    0.11713\n",
      "epoch: 18400.00000 | total_loss:    0.12188 | domain_loss:    0.70327 | bdc_loss:    0.11601\n",
      "epoch: 18600.00000 | total_loss:    0.12123 | domain_loss:    0.77093 | bdc_loss:    0.11467\n",
      "epoch: 18800.00000 | total_loss:    0.12037 | domain_loss:    0.84552 | bdc_loss:    0.11304\n",
      "epoch: 19000.00000 | total_loss:    0.11922 | domain_loss:    0.92718 | bdc_loss:    0.11106\n",
      "epoch: 19200.00000 | total_loss:    0.11764 | domain_loss:    1.01565 | bdc_loss:    0.10857\n",
      "epoch: 19400.00000 | total_loss:    0.11538 | domain_loss:    1.10988 | bdc_loss:    0.10533\n",
      "epoch: 19600.00000 | total_loss:    0.11196 | domain_loss:    1.20794 | bdc_loss:    0.10089\n",
      "epoch: 19800.00000 | total_loss:    0.10613 | domain_loss:    1.31492 | bdc_loss:    0.09392\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0001), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.09387075768284447"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((uxy[0,:,:,0]-truth_data)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth':np.asarray(truth_smooth),\n",
    "                     'samples':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0)}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
